﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using itau.im.entidade;
using itau.im.dado;
using EnterpriseLibraryWrapper;
using System.ServiceModel;
using System.Collections;
using itau.im.interpolador;
using System.Data;
using System.IO;
using itau.im.negocio.conversor;


namespace itau.im.negocio
{

    public class ExecucaoCurvaBS : IExecucaoCurvaBS
    {

        #region Constantes

        private const int VERTICES_CORRIGIDOS = 15;
        private const int EM_EXECUCAO = 16;
        private const int AGUARDANDO_LIBERACAO = 17;
        private const int RETIDA = 20;
        private const int LIBERADA = 40;

        private const int TIPO_COMPOSTA = 1;

        private const int ANTEPOLACAO = 1;
        private const int INTERPOLACAO = 2;
        private const int EXTRAPOLACAO = 3;
        private const int TIPO_VERTICE = 4;

        #endregion

        #region Atributos

        private List<CurvaVigente> listaCurvasCompostas = new List<CurvaVigente>();

        #endregion

        #region Métodos

        public IList<RegistroExecucaoCurva> ObterRegistrosExecucaoCurvaLikeNome(DateTime dataInicio, DateTime dataFim, int codigoTipoCurva, int codigoModalidade, string nomeCurva, int codigoSituacao, int codigoMoeda, int codigoTipoEntradaDado, int codigoSubMesa, int codigoCategoriaMercado)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                //return execucaoCurvaDAO.ObterRegistrosExecucaoCurvaLikeNome(dataInicio, dataFim, codigoTipoCurva, codigoModalidade, string.Format("%{0}%", nomeCurva), codigoSituacao);
                return execucaoCurvaDAO.ObterRegistrosExecucaoCurvaLikeNome(dataInicio, dataFim, codigoTipoCurva, codigoModalidade, nomeCurva, codigoSituacao, codigoMoeda, codigoTipoEntradaDado, codigoSubMesa, codigoCategoriaMercado);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<RegistroExecucaoCurva>();
        }

        public void PersistirExecucao(IList<CurvaExecucaoPonto> vertices, RegistroExecucaoCurva registroExecucao)
        {
            ICurvaDAO curvaDAO;
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                execucaoCurvaDAO.PersistirExecucao(vertices, registroExecucao);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                execucaoCurvaDAO = null;
            }
        }

        public IList<RegistroExecucaoCurva> ObterRegistrosExecucaoCurva(int codigoCurva, DateTime dataHoraExecucao, int codigoSituacao)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                return execucaoCurvaDAO.ObterRegistrosExecucaoCurva(codigoCurva, dataHoraExecucao, codigoSituacao);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<RegistroExecucaoCurva>();
        }

        public void CriarRegistroExecucaoCurva(RegistroExecucaoCurva registroExecucaoCurva)
        {
            ICurvaDAO curvaDAO;
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                execucaoCurvaDAO.CriarRegistroExecucaoCurva(registroExecucaoCurva);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosDados");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                execucaoCurvaDAO = null;
            }
        }

        public RegistroExecucaoCurva ObterRegistroExecucaoCurva(int curvaID, DateTime dataInclusaoVigencia, DateTime dataHoraExecucaoCurva)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                return execucaoCurvaDAO.ObterRegistroExecucaoCurva(curvaID, dataInclusaoVigencia, dataHoraExecucaoCurva);

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {

                execucaoCurvaDAO = null;
            }

            return new RegistroExecucaoCurva();
        }

        public void RemoverCurvaExecucaoPontos(RegistroExecucaoCurva registroExecucaoCurva)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.RemoverCurvaExecucaoPontos(registroExecucaoCurva, 0);
                execucaoCurvaDAO.RemoverCurvaExecucaoPontos(registroExecucaoCurva, 1);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void RemoverCurvaExecucaoPontos(RegistroExecucaoCurva registroExecucaoCurva, int indicadorVertice)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.RemoverCurvaExecucaoPontos(registroExecucaoCurva, indicadorVertice);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void RemoverCurvaExecucaoPontos(RegistroExecucaoCurva registroExecucaoCurva, List<string> procedures)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;
            int INDICADOR_VERTICE_NAO = 0;
            int INDICADOR_VERTICE_SIM = 1;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.RemoverCurvaExecucaoPontos(registroExecucaoCurva, INDICADOR_VERTICE_NAO, procedures);
                execucaoCurvaDAO.RemoverCurvaExecucaoPontos(registroExecucaoCurva, INDICADOR_VERTICE_SIM, procedures);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void RemoverCurvaExecucaoPontos(RegistroExecucaoCurva registroExecucaoCurva, int indicadorVertice, List<string> procedures)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.RemoverCurvaExecucaoPontos(registroExecucaoCurva, indicadorVertice, procedures);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void AgendarGeracaoCurvasCompostas(int codigoCurvaComponente)
        {
            RegistroExecucaoCurva registroExecucaoCurva;
            ICurvaDAO curvaDAO;
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                CurvaVigente curvaVigente = curvaDAO.ObterCurvaVigente(codigoCurvaComponente);
                IList<ItemComposicao> listaItemComposicao = curvaDAO.ObterItensComposicao(codigoCurvaComponente, curvaVigente.DataInclusao);

                if (listaItemComposicao != null && listaItemComposicao.Count > 0)
                {
                    execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                    foreach (ItemComposicao item in listaItemComposicao)
                    {
                        registroExecucaoCurva = new RegistroExecucaoCurva();

                        registroExecucaoCurva.CodigoCurva = item.CodigoCurvaIntegrante;
                        registroExecucaoCurva.DataInclusaoVigencia = item.DataInclusaoVigencia;
                        registroExecucaoCurva.DataHoraExecucaoCurva = DateTime.Now;
                        registroExecucaoCurva.CodigoSituacao = 11;
                        registroExecucaoCurva.CodigoTipoEventoNotificacao = 0;

                        execucaoCurvaDAO.CriarRegistroExecucaoCurva(registroExecucaoCurva);
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                registroExecucaoCurva = null;
                curvaDAO = null;
                execucaoCurvaDAO = null;
            }
        }

        private void ObterCurvasCompostas(List<CurvaVigente> lstCurvaVigente)
        {
            List<CurvaVigente> lstRetorno;
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                listaCurvasCompostas.AddRange(lstCurvaVigente);

                foreach (CurvaVigente objCurvaVigente in lstCurvaVigente)
                {
                    lstRetorno = curvaDAO.ObterCurvasCompostasVigentesPeloFator(objCurvaVigente.CodigoCurvaVigente).ToList<CurvaVigente>();
                    ObterCurvasCompostas(lstRetorno);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                lstRetorno = null;
                curvaDAO = null;
            }
        }

        public IList<RegistroExecucaoCurva> ObterRegistrosExecucaoCurvaPorCurvaVigente(int curvaVigenteID)
        {
            IList<RegistroExecucaoCurva> listaRegistros = null;
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                listaRegistros = execucaoCurvaDAO.ObterRegistrosExecucaoCurvaPorCurvaVigente(curvaVigenteID);
                return listaRegistros;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaRegistros = null;
                execucaoCurvaDAO = null;
            }

            return new List<RegistroExecucaoCurva>();
        }

        public IList<RegistroExecucaoCurva> ObterRegistrosExecucaoCurva(DateTime dataHoraFim, int codigoSituacaoInicio, int codigoSituacaoFim)
        {
            IList<RegistroExecucaoCurva> listaRegistros = null;
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                listaRegistros = execucaoCurvaDAO.ObterRegistrosExecucaoCurva(dataHoraFim, codigoSituacaoInicio, codigoSituacaoFim);
                return listaRegistros;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaRegistros = null;
                execucaoCurvaDAO = null;
            }

            return new List<RegistroExecucaoCurva>();
        }

        public IList<RegistroExecucaoCurva> ObterRegistrosExecucaoCurvaTransferPrice(DateTime dataHoraFim, int codigoSituacaoInicio, int codigoSituacaoFim)
        {
            IList<RegistroExecucaoCurva> listaRegistros = null;
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                listaRegistros = execucaoCurvaDAO.ObterRegistrosExecucaoCurvaTransferPrice(dataHoraFim, codigoSituacaoInicio, codigoSituacaoFim);
                return listaRegistros;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaRegistros = null;
                execucaoCurvaDAO = null;
            }

            return new List<RegistroExecucaoCurva>();
        }

        public IList<RegistroExecucaoCurva> ObterRegistrosExecucaoCurvaPricingBIHF(DateTime dataHoraFim, int codigoSituacaoInicio, int codigoSituacaoFim)
        {
            IList<RegistroExecucaoCurva> listaRegistros = null;
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                listaRegistros = execucaoCurvaDAO.ObterRegistrosExecucaoCurvaPricingBIHF(dataHoraFim, codigoSituacaoInicio, codigoSituacaoFim);
                return listaRegistros;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaRegistros = null;
                execucaoCurvaDAO = null;
            }

            return new List<RegistroExecucaoCurva>();
        }

        public IList<RegistroExecucaoCurva> ObterRegistrosExecucaoCurva(DateTime dataHoraFim, int codigoSituacaoInicio, int codigoSituacaoFim, int codigoTipoCurva)
        {
            IList<RegistroExecucaoCurva> listaRegistros = null;
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                listaRegistros = execucaoCurvaDAO.ObterRegistrosExecucaoCurva(dataHoraFim, codigoSituacaoInicio, codigoSituacaoFim, codigoTipoCurva);
                return listaRegistros;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaRegistros = null;
                execucaoCurvaDAO = null;
            }

            return new List<RegistroExecucaoCurva>();
        }

        public IList<LiberacaoCurva> ObterExecucaoCurvasFuturasPorTipoMesaCategoriaData(int tipoCurvaID, int subMesaID, int categoriaMercadoID, DateTime dataReferencia)
        {
            IList<LiberacaoCurva> listaLiberacaoCurvas;
            IList<GradeExecucaoCurva> listaGradeExecucao;
            List<RegistroGradeExecucaoCurva> listaRegistroGradeExecucaoFuturo;
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                listaLiberacaoCurvas = new List<LiberacaoCurva>();
                listaGradeExecucao = curvaDAO.ObterGradesExecucaoCurvasAtivas();

                foreach (GradeExecucaoCurva itemGrade in listaGradeExecucao)
                {
                    if (dataReferencia.Date == DateTime.Now.Date)
                    {
                        //Filtra apenas itens da grade execução futuros
                        listaRegistroGradeExecucaoFuturo = curvaDAO.ObterRegistrosGradeExecucaoCurva(itemGrade.CodigoCurva)
                            .Where(p => p.HoraExecucao.TimeOfDay > DateTime.Now.TimeOfDay).ToList();
                    }
                    else if (dataReferencia.Date > DateTime.Now.Date)
                    {
                        listaRegistroGradeExecucaoFuturo = curvaDAO.ObterRegistrosGradeExecucaoCurva(itemGrade.CodigoCurva).ToList();
                    }
                    else
                    {
                        listaRegistroGradeExecucaoFuturo = null;
                    }

                    if (listaRegistroGradeExecucaoFuturo != null
                        && listaRegistroGradeExecucaoFuturo.Count > 0)
                    {
                        Curva curva = curvaDAO.ObterCurva(itemGrade.CodigoCurva);

                        if ((tipoCurvaID != 0 ? curva.CodigoTipoCurva == tipoCurvaID : true)
                            && (subMesaID != 0 ? curva.CodigoSubMesaOperacao == subMesaID : true)
                            && (categoriaMercadoID != 0 ? curva.CodigoCategoriaMercado == categoriaMercadoID : true))
                        {
                            TaxaPontoCurvaVigente taxaPontoCurva = curva.CurvaVigente.lstTaxaPontoCurvaVigente.FirstOrDefault(p => p.CodigoTipoPontoCurva == 4);

                            foreach (RegistroGradeExecucaoCurva itemRegistro in listaRegistroGradeExecucaoFuturo)
                            {
                                listaLiberacaoCurvas.Add(new LiberacaoCurva()
                                {
                                    CodigoCurva = itemGrade.CodigoCurva,
                                    DataHoraExecucaoCurva = itemRegistro.HoraExecucao,
                                    NomeCurva = curva.NomeCurva,
                                    DescricaoCurva = curva.DescricaoCurva,
                                    CodigoTipoEntradaDado = curva.CurvaVigente.CodigoTipoEntradaDado,
                                    CodigoTipoPrazo = curva.CurvaVigente.CodigoTipoPrazo,
                                    CodigoTipoTaxa = curva.CurvaVigente.CodigoTipoTaxa,
                                    CodigoTipoVertice = taxaPontoCurva.CodigoTipoTaxa,
                                    CodigoSituacao = 18
                                });
                            }
                        }
                    }
                }

                return listaLiberacaoCurvas;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaLiberacaoCurvas = null;
                listaGradeExecucao = null;
                listaRegistroGradeExecucaoFuturo = null;
                curvaDAO = null;
            }

            return new List<LiberacaoCurva>();
        }

        public IList<LiberacaoCurva> ObterExecucaoCurvasFuturasPorDataReferencia(int codigoTipoCurva, int codigoModalidade, int codigoSubMesa, int codigoCategoriaMercado, int codigoMoeda, int codigoTipoEntradaDado, string nomeCurva, DateTime dataReferencia)
        {
            IList<LiberacaoCurva> listaLiberacaoCurvas;
            IList<GradeExecucaoCurva> listaGradeExecucao;
            List<RegistroGradeExecucaoCurva> listaRegistroGradeExecucaoFuturo;
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                listaLiberacaoCurvas = new List<LiberacaoCurva>();
                listaGradeExecucao = curvaDAO.ObterGradesExecucaoCurvasAtivas();

                foreach (GradeExecucaoCurva itemGrade in listaGradeExecucao)
                {
                    if (dataReferencia.Date == DateTime.Now.Date)
                    {
                        //Filtra apenas itens da grade execução futuros
                        listaRegistroGradeExecucaoFuturo = curvaDAO.ObterRegistrosGradeExecucaoCurva(itemGrade.CodigoCurva)
                            .Where(p => p.HoraExecucao.TimeOfDay > DateTime.Now.TimeOfDay).ToList();
                    }
                    else if (dataReferencia.Date > DateTime.Now.Date)
                    {
                        listaRegistroGradeExecucaoFuturo = curvaDAO.ObterRegistrosGradeExecucaoCurva(itemGrade.CodigoCurva).ToList();
                    }
                    else
                    {
                        listaRegistroGradeExecucaoFuturo = null;
                    }

                    if (listaRegistroGradeExecucaoFuturo != null
                        && listaRegistroGradeExecucaoFuturo.Count > 0)
                    {
                        Curva curva = curvaDAO.ObterCurva(itemGrade.CodigoCurva);

                        if ((codigoTipoCurva != 0 ? curva.CodigoTipoCurva == codigoTipoCurva : true)
                         && (codigoMoeda != 0 ? curva.CurvaVigente.CodigoMoeda == codigoMoeda : true)
                         && (codigoSubMesa != 0 ? curva.CodigoSubMesaOperacao == codigoSubMesa : true)
                         && (codigoModalidade != 0 ? curva.CodigoModalidadeCurva == codigoModalidade : true)
                         && (codigoCategoriaMercado != 0 ? curva.CodigoCategoriaMercado == codigoCategoriaMercado : true)
                         && (codigoTipoEntradaDado != 0 ? curva.CurvaVigente.CodigoTipoEntradaDado == codigoTipoEntradaDado : true)
                         && (!string.IsNullOrEmpty(nomeCurva) ? curva.NomeCurva.Contains(nomeCurva) : true))
                        {
                            TaxaPontoCurvaVigente taxaPontoCurva = curva.CurvaVigente.lstTaxaPontoCurvaVigente.FirstOrDefault(p => p.CodigoTipoPontoCurva == 4);

                            foreach (RegistroGradeExecucaoCurva itemRegistro in listaRegistroGradeExecucaoFuturo)
                            {
                                listaLiberacaoCurvas.Add(new LiberacaoCurva()
                                    {
                                        CodigoCurva = itemGrade.CodigoCurva,
                                        DataHoraExecucaoCurva = itemRegistro.HoraExecucao,
                                        NomeCurva = curva.NomeCurva,
                                        DescricaoCurva = curva.DescricaoCurva,
                                        CodigoTipoEntradaDado = curva.CurvaVigente.CodigoTipoEntradaDado,
                                        CodigoTipoPrazo = curva.CurvaVigente.CodigoTipoPrazo,
                                        CodigoTipoTaxa = curva.CurvaVigente.CodigoTipoTaxa,
                                        CodigoTipoVertice = taxaPontoCurva.CodigoTipoTaxa,
                                        CodigoSituacao = 18
                                    });
                            }
                        }
                    }
                }

                return listaLiberacaoCurvas;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaLiberacaoCurvas = null;
                listaGradeExecucao = null;
                listaRegistroGradeExecucaoFuturo = null;
                curvaDAO = null;
            }

            return new List<LiberacaoCurva>();
        }

        public void AtualizarCurvaExecucaoPontos(IList<CurvaExecucaoPonto> vertices)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.AtualizarCurvaExecucaoPontos(vertices);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void AtualizarRegistroExecucaoCurva(RegistroExecucaoCurva registroExecucaoCurva)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.AtualizarRegistroExecucaoCurva(registroExecucaoCurva);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

        }

        public IList<CurvaExecucaoPonto> ObterVerticesCurvaVigente(int curvaID, DateTime dataInclusaoVigencia, DateTime dataHoraExecucaoCurva)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                return execucaoCurvaDAO.ObterCurvaExecucaoPontosAnaliseRetida(curvaID, dataInclusaoVigencia, dataHoraExecucaoCurva);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<CurvaExecucaoPonto>();
        }

        public void AtualizarSituacaoRegistrosExecucaoCurva(int codigoCurva, DateTime dataExecucao, int codigoSituacaoAtual, int codigoSituacaoNova)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.AtualizarSituacaoRegistrosExecucaoCurva(codigoCurva, dataExecucao, codigoSituacaoAtual, codigoSituacaoNova);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public IList<CurvaVigente> ObterUltimaExecucaoCurvas(IList<CurvaVigente> listaCurvasVigente)
        {
            int REJEITADO = 99;
            IExecucaoCurvaDAO execucaoCurvaDAO;
            ICurvaDAO curvaDAO;
            RegistroExecucaoCurva registroExecucaoCurva = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                foreach (CurvaVigente objCurvaVigente in listaCurvasVigente)
                {
                    registroExecucaoCurva = execucaoCurvaDAO.ObterUltimaExecucaoCurva(objCurvaVigente.CodigoCurvaVigente, objCurvaVigente.DataInclusao, System.DateTime.Now, REJEITADO);

                    if (registroExecucaoCurva == null)
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();
                        Curva curva = curvaDAO.ObterDadosBasicosCurva(objCurvaVigente.CodigoCurvaVigente);
                        throw new NegociosException(string.Format("Não foi possível obter a última execução da curva primária. Código da curva primária: {0}. Nome da curva: {1}. Data inclusão: {2}", objCurvaVigente.CodigoCurvaVigente, curva.NomeCurva, objCurvaVigente.DataInclusao));
                    }
                    else if (registroExecucaoCurva.DataHoraExecucaoCurva.Date != System.DateTime.Now.Date)
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();
                        Curva curva = curvaDAO.ObterDadosBasicosCurva(objCurvaVigente.CodigoCurvaVigente);
                        throw new NegociosException(string.Format("A última execução da curva primária está desatualizada. Código da curva primária: {0}. Nome da curva: {1}. Data inclusão: {2}. Data hora execução: {3}", objCurvaVigente.CodigoCurvaVigente, curva.NomeCurva, objCurvaVigente.DataInclusao, registroExecucaoCurva.DataHoraExecucaoCurva));
                    }

                    registroExecucaoCurva.CurvaExecucaoPonto = (execucaoCurvaDAO.ObterCurvaExecucaoPontosAnaliseRetida(registroExecucaoCurva.CodigoCurva, registroExecucaoCurva.DataInclusaoVigencia, registroExecucaoCurva.DataHoraExecucaoCurva));
                    objCurvaVigente.RegistroExecucaoCurva = new List<RegistroExecucaoCurva>();
                    objCurvaVigente.RegistroExecucaoCurva.Add(registroExecucaoCurva);
                }

                return listaCurvasVigente;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
                registroExecucaoCurva = null;
            }

            return new List<CurvaVigente>();
        }

        public IList<CurvaExecucaoPonto> ObterPontosCurvaDataReferencia(int codigoCurva, DateTime dataReferencia)
        {
            int LIBERADA = 40;
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                RegistroExecucaoCurva registroExecucaoCurva = execucaoCurvaDAO.ObterUltimaExecucaoCurva(codigoCurva, dataReferencia, LIBERADA);

                if (registroExecucaoCurva != null
                    && registroExecucaoCurva.DataHoraExecucaoCurva.Date == dataReferencia.Date)
                {
                    return execucaoCurvaDAO.ObterCurvaExecucaoPontosAnaliseRetida(registroExecucaoCurva.CodigoCurva, registroExecucaoCurva.DataInclusaoVigencia, registroExecucaoCurva.DataHoraExecucaoCurva);
                }
                else
                {
                    return new List<CurvaExecucaoPonto>();
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<CurvaExecucaoPonto>();
        }

        public IList<CurvaVigente> ObterUltimaExecucaoCurvasDataReferencia(IList<Curva> listaCurvas, DateTime dataReferencia)
        {
            int LIBERADA = 40;
            IExecucaoCurvaDAO execucaoCurvaDAO;
            RegistroExecucaoCurva registroExecucaoCurva = null;
            List<CurvaVigente> listaCurvasVigente = new List<CurvaVigente>();
            ICurvaDAO curvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                foreach (Curva objCurva in listaCurvas)
                {
                    registroExecucaoCurva = execucaoCurvaDAO.ObterUltimaExecucaoCurva(objCurva.CodigoCurva, dataReferencia, LIBERADA);

                    if (registroExecucaoCurva == null)
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();
                        Curva curva = curvaDAO.ObterDadosBasicosCurva(objCurva.CodigoCurva);
                        throw new NegociosException(string.Format("Não foi possível obter a última execução da curva primária. Código da curva primária: {0}. Nome da curva: {1}. Data referência: {2}", objCurva.CodigoCurva, curva.NomeCurva, dataReferencia));
                    }
                    else if (registroExecucaoCurva.DataHoraExecucaoCurva.Date != dataReferencia.Date)
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();
                        Curva curva = curvaDAO.ObterDadosBasicosCurva(objCurva.CodigoCurva);
                        throw new NegociosException(string.Format("A última execução da curva primária está desatualizada. Código da curva primária: {0}. Nome da curva: {1}. Data referência: {2}. Data hora execução: {3}", objCurva.CodigoCurva, curva.NomeCurva, dataReferencia, registroExecucaoCurva.DataHoraExecucaoCurva));
                    }

                    registroExecucaoCurva.CurvaExecucaoPonto = execucaoCurvaDAO.ObterCurvaExecucaoPontosAnaliseRetida(registroExecucaoCurva.CodigoCurva, registroExecucaoCurva.DataInclusaoVigencia, registroExecucaoCurva.DataHoraExecucaoCurva);
                    CurvaVigente objCurvaVigente = new CurvaVigente();
                    objCurvaVigente.CodigoCurvaVigente = objCurva.CodigoCurva;
                    objCurvaVigente.RegistroExecucaoCurva = new List<RegistroExecucaoCurva>();
                    objCurvaVigente.RegistroExecucaoCurva.Add(registroExecucaoCurva);
                    listaCurvasVigente.Add(objCurvaVigente);
                }

                return listaCurvasVigente;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
                registroExecucaoCurva = null;
            }

            return new List<CurvaVigente>();
        }

        public IList<CurvaVigente> ObterUltimaExecucaoCurvasDataReferencia(IList<Curva> listaCurvas, DateTime dataReferencia, string procedure)
        {
            int LIBERADA = 40;
            IExecucaoCurvaDAO execucaoCurvaDAO;
            RegistroExecucaoCurva registroExecucaoCurva = null;
            List<CurvaVigente> listaCurvasVigente = new List<CurvaVigente>();
            ICurvaDAO curvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                foreach (Curva objCurva in listaCurvas)
                {
                    registroExecucaoCurva = execucaoCurvaDAO.ObterUltimaExecucaoCurva(objCurva.CodigoCurva, dataReferencia, LIBERADA);

                    if (registroExecucaoCurva == null)
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();
                        Curva curva = curvaDAO.ObterDadosBasicosCurva(objCurva.CodigoCurva);
                        throw new NegociosException(string.Format("Não foi possível obter a última execução da curva primária. Código da curva primária: {0}. Nome da curva: {1}. Data referência: {2}", objCurva.CodigoCurva, curva.NomeCurva, dataReferencia));
                    }
                    else if (registroExecucaoCurva.DataHoraExecucaoCurva.Date != dataReferencia.Date)
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();
                        Curva curva = curvaDAO.ObterDadosBasicosCurva(objCurva.CodigoCurva);
                        throw new NegociosException(string.Format("A última execução da curva primária está desatualizada. Código da curva primária: {0}. Nome da curva: {1}. Data referência: {2}. Data hora execução: {3}", objCurva.CodigoCurva, curva.NomeCurva, dataReferencia, registroExecucaoCurva.DataHoraExecucaoCurva));
                    }

                    registroExecucaoCurva.CurvaExecucaoPonto = execucaoCurvaDAO.ObterCurvaExecucaoPontosAnaliseRetida(registroExecucaoCurva.CodigoCurva, registroExecucaoCurva.DataInclusaoVigencia, registroExecucaoCurva.DataHoraExecucaoCurva, procedure);
                    CurvaVigente objCurvaVigente = new CurvaVigente();
                    objCurvaVigente.CodigoCurvaVigente = objCurva.CodigoCurva;
                    objCurvaVigente.RegistroExecucaoCurva = new List<RegistroExecucaoCurva>();
                    objCurvaVigente.RegistroExecucaoCurva.Add(registroExecucaoCurva);
                    listaCurvasVigente.Add(objCurvaVigente);
                }

                return listaCurvasVigente;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
                registroExecucaoCurva = null;
            }

            return new List<CurvaVigente>();
        }

        public RegistroExecucaoCurva ObterUltimaExecucaoCurva(int curvaID, DateTime dataInclusaoVigencia, DateTime dataReferencia, int codigoSituacao)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                return execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curvaID, dataInclusaoVigencia, dataReferencia, codigoSituacao);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new RegistroExecucaoCurva();
        }

        public RegistroExecucaoCurva ObterRegistroExecucaoCurva(int codigoCurva, DateTime dataInclusao, DateTime dataReferencia, int codigoSituacao)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                return execucaoCurvaDAO.ObterRegistroExecucaoCurva(codigoCurva, dataInclusao, dataReferencia, codigoSituacao);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new RegistroExecucaoCurva();
        }

        public RegistroExecucaoCurva ObterRegistroExecucaoCurva(int curvaID, DateTime dataInclusaoVigencia)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;
            RegistroExecucaoCurva registroExecucaoCurva;

            try
            {
                registroExecucaoCurva = new RegistroExecucaoCurva();
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                registroExecucaoCurva = execucaoCurvaDAO.ObterRegistroExecucaoCurva(curvaID, dataInclusaoVigencia);
                return registroExecucaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
                registroExecucaoCurva = null;
            }

            return new RegistroExecucaoCurva();
        }

        public void CriarCurvaExecucaoPontos(IList<CurvaExecucaoPonto> vertices)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.CriarCurvaExecucaoPontosEmLote(vertices);
                //execucaoCurvaDAO.CriarCurvaExecucaoPontos(vertices);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void CriarCurvaExecucaoPontos(IList<CurvaExecucaoPonto> vertices, string nomeProcedure)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.CriarCurvaExecucaoPontosEmLote(vertices, nomeProcedure);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void AlterarExecucaoRemoverPontos(RegistroExecucaoCurva registro)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.AlterarExecucaoRemoverPontos(registro);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void AlterarExecucaoRemoverPontos(RegistroExecucaoCurva registro, List<string> procedures)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                execucaoCurvaDAO.AlterarExecucaoRemoverPontos(registro, procedures);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void CriarOuAtualizarCurvaExecucaoPontos(IList<CurvaExecucaoPonto> vertices)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;
            ICurvaDAO curvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                curvaDAO = DaoFactory.getCurvaDAO();

                foreach (CurvaExecucaoPonto vertice in vertices)
                {
                    execucaoCurvaDAO.CriarOuAtualizarCurvaExecucaoPonto(vertice);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
                curvaDAO = null;
            }
        }

        public void CriarCurvaExecucaoPontosPorImportacao(IList<CurvaExecucaoPonto> vertices, DateTime dataExtensao)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;
            CalendarioReguaBS regua = null;

            try
            {
                if (vertices.Count > 0)
                {
                    execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                    regua = new CalendarioReguaBS(vertices[0].DataHoraExecucaoCurva, dataExtensao);

                    foreach (CurvaExecucaoPonto vertice in vertices)
                    {
                        vertice.QuantidadeDiasUteis = regua.ObterQuantidadeDiasUteis(vertice.DataVencimento.Date.ToString("yyyyMMdd"));
                    }
                    regua.Dispose();
                    execucaoCurvaDAO.CriarCurvaExecucaoPontos(vertices);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
                regua = null;
            }
        }

        public IList<LiberacaoCurva> ObterCurvasRetidasPorTipoMesaCategoria(int tipoCurvaID, int subMesaID, int categoriaMercadoID)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = null;
            IList<LiberacaoCurva> listaLiberacaoCurva = null;
            IList<LiberacaoCurva> listaLiberacaoCurvaConcat = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                listaLiberacaoCurva = execucaoCurvaDAO.ObterCurvasPorTipoMesaCategoriaSituacao(tipoCurvaID, subMesaID, categoriaMercadoID, 2);

                listaLiberacaoCurvaConcat = execucaoCurvaDAO.ObterCurvasPorTipoMesaCategoriaSituacao(tipoCurvaID, subMesaID, categoriaMercadoID, 20);

                foreach (LiberacaoCurva item in listaLiberacaoCurvaConcat)
                {
                    listaLiberacaoCurva.Add(item);
                }

                return listaLiberacaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
                listaLiberacaoCurvaConcat = null;
            }

            return new List<LiberacaoCurva>();
        }

        public IList<LiberacaoCurva> ObterCurvasPorTipoMesaCategoriaSituacao(int tipoCurvaID, int subMesaID, int categoriaMercadoID, int codigoSituacao)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;
            IList<LiberacaoCurva> listaLiberacaoCurva;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                listaLiberacaoCurva = execucaoCurvaDAO.ObterCurvasPorTipoMesaCategoriaSituacao(tipoCurvaID, subMesaID, categoriaMercadoID, codigoSituacao);

                return listaLiberacaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<LiberacaoCurva>();
        }

        public IList<LiberacaoCurva> ObterCurvasPorTipoMesaCategoriaSituacaoData(int tipoCurvaID, int subMesaID, int categoriaMercadoID, int codigoSituacao, DateTime dataReferencia)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;
            IList<LiberacaoCurva> listaLiberacaoCurva;

            ICurvaDAO curvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                curvaDAO = DaoFactory.getCurvaDAO();

                listaLiberacaoCurva = execucaoCurvaDAO.ObterCurvasPorTipoMesaCategoriaSituacaoData(tipoCurvaID, subMesaID, categoriaMercadoID, codigoSituacao, dataReferencia);

                foreach (LiberacaoCurva item in listaLiberacaoCurva)
                {
                    Curva curva = curvaDAO.ObterCurva(item.CodigoCurva);
                    CurvaVigente curvaVigente = curvaDAO.ObterCurvaVigentePorDataReferencia(item.CodigoCurva, item.DataInclusaoVigencia);

                    if (curvaVigente.CodigoCurvaVigente == 0)
                    {
                        curvaVigente = curvaDAO.ObterCurvaVigentePorDataReferencia(item.CodigoCurva, item.DataHoraExecucaoCurva);
                    }

                    if (curva != null)
                    {
                        item.DescricaoCurva = curva.DescricaoCurva;
                    }

                    if (curvaVigente != null)
                    {
                        TaxaPontoCurvaVigente taxaPontoCurva = curvaVigente.lstTaxaPontoCurvaVigente.FirstOrDefault(p => p.CodigoTipoPontoCurva == 4);

                        item.CodigoTipoEntradaDado = curvaVigente.CodigoTipoEntradaDado;
                        item.CodigoTipoPrazo = curvaVigente.CodigoTipoPrazo;
                        item.CodigoTipoTaxa = curvaVigente.CodigoTipoTaxa;
                        item.CodigoTipoVertice = taxaPontoCurva != null ? taxaPontoCurva.CodigoTipoTaxa : 0;
                    }
                }

                return listaLiberacaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<LiberacaoCurva>();
        }

        public IList<LiberacaoCurva> ObterLiberacoesPorCurvaSituacaoPeriodo(int curvaID, int codigoSituacao, DateTime dataInicio, DateTime dataFim)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;
            IList<LiberacaoCurva> listaLiberacaoCurva;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                listaLiberacaoCurva = execucaoCurvaDAO.ObterLiberacoesPorCurvaSituacaoPeriodo(curvaID, codigoSituacao, dataInicio, dataFim);

                return listaLiberacaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<LiberacaoCurva>();
        }

        public IList<LiberacaoCurva> ObterCurvasParaLiberacaoRejeicaoConsulta(int codigoTipoCurva, int codigoSubMesa, int codigoCategoriaMercado, int codigoModalidade, int codigoSituacao, int codigoMoeda, int codigoTipoEntradaDado, string nomeCurva, DateTime dataHoraInicio, DateTime dataHoraFim)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;
            IList<LiberacaoCurva> listaLiberacaoCurva;

            ICurvaDAO curvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                curvaDAO = DaoFactory.getCurvaDAO();

                listaLiberacaoCurva = execucaoCurvaDAO.ObterCurvasParaLiberacaoRejeicaoConsulta(codigoTipoCurva, codigoSubMesa, codigoCategoriaMercado, codigoModalidade, codigoSituacao, codigoMoeda, codigoTipoEntradaDado, nomeCurva, dataHoraInicio, dataHoraFim);

                return listaLiberacaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<LiberacaoCurva>();
        }

        public IList<CurvaExecucaoPonto> ObterCurvaExecucaoPontosPaginada(int curvaID, DateTime dataInclusaoVigencia, DateTime dataHoraExecucaoCurva, int pagina)
        {
            try
            {
                return PaginarLista<CurvaExecucaoPonto>(ObterCurvaExecucaoPontos(curvaID, dataInclusaoVigencia, dataHoraExecucaoCurva), pagina);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return new List<CurvaExecucaoPonto>();
        }

        public IList<CurvaExecucaoPonto> ObterCurvaExecucaoPontos(int curvaID, DateTime dataInclusaoVigencia, DateTime dataHoraExecucaoCurva)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                return execucaoCurvaDAO.ObterCurvaExecucaoPontosAnaliseRetida(curvaID, dataInclusaoVigencia, dataHoraExecucaoCurva);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<CurvaExecucaoPonto>();
        }

        public DataSet ObterCurvaExecucaoPontosDataSet(int curvaID, DateTime dataInclusaoVigencia, DateTime dataHoraExecucaoCurva, DateTime dataLimite, int codigoTipoTaxa, int codigoTipoBase)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;
            ICurvaDAO curvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                curvaDAO = DaoFactory.getCurvaDAO();

                DataSet pontosDataSet = execucaoCurvaDAO.ObterCurvaExecucaoPontosDataSet(curvaID, dataInclusaoVigencia, dataHoraExecucaoCurva, dataLimite);

                CurvaVigente curvaVigente = curvaDAO.ObterCurvaVigentePorDataReferencia(curvaID, dataInclusaoVigencia.AddMinutes(-1));
                Curva curva = curvaDAO.ObterCurva(curvaID);

                if (ConsultaTrouxeResultado(pontosDataSet)
                    && CurvaTemTipoVertice(curvaVigente)
                    && ValidarIndexador(curva)
                    && codigoTipoTaxa != 0)
                {
                    ConverterTaxas(pontosDataSet, curvaVigente, codigoTipoTaxa, codigoTipoBase);
                }

                return pontosDataSet;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new DataSet();
        }

        private void ConverterTaxas(DataSet pontosDataSet, CurvaVigente curvaVigenteOrigem, int codigoTipoTaxaDestino, int codigoTipoBaseDestino)
        {
            const int VERTICE = 4;
            const int EXPONENCIAL = 1;
            const int LINEAR = 2;
            const int FATOR_DIARIO = 3;
            const int PU = 4;
            const int TAXA = 7;

            const int BASE_DU252 = 1;

            const string COLUNA_DC = "QTD_DIA_CRRI";
            const string COLUNA_DU = "QTD_DIA_UTIL";
            const string COLUNA_VALOR_PONTO = "VLR_PONT";
            const string COLUNA_DC_DURATION = "QTD_DURC_DIA_CRRI";
            const string COLUNA_DU_DURATION = "QTD_DURC_DIA_UTIL";

            ConversorTaxas conversorTaxas = new ConversorTaxas();

            TaxaPontoCurvaVigente tipoVerticeOrigem = curvaVigenteOrigem.lstTaxaPontoCurvaVigente.FirstOrDefault<TaxaPontoCurvaVigente>(t => t.CodigoTipoPontoCurva == VERTICE);

            foreach (DataRow linha in pontosDataSet.Tables[0].Rows)
            {
                if (tipoVerticeOrigem.CodigoTipoTaxa == FATOR_DIARIO)
                {
                    if (codigoTipoTaxaDestino == TAXA)
                    {
                        if (curvaVigenteOrigem.CodigoTipoTaxa == EXPONENCIAL)
                        {
                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverterFatorDiarioParaExponencial(
                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                RetornarDiasAnoPorTipoBase(codigoTipoBaseDestino),
                                RetornarNumeroDias(codigoTipoBaseDestino,
                                ConverterParaInt(linha[COLUNA_DC]),
                                ConverterParaInt(linha[COLUNA_DU])));
                        }
                        else if (curvaVigenteOrigem.CodigoTipoTaxa == LINEAR)
                        {
                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverterFatorDiarioParaLinear(
                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                RetornarDiasAnoPorTipoBase(codigoTipoBaseDestino),
                                RetornarNumeroDias(codigoTipoBaseDestino,
                                ConverterParaInt(linha[COLUNA_DC]),
                                ConverterParaInt(linha[COLUNA_DU])));
                        }
                    }
                    else if (codigoTipoTaxaDestino == PU)
                    {
                        linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverterFatorDiarioParaPU(ConverterParaDouble(linha[COLUNA_VALOR_PONTO]));
                    }
                }
                else if (tipoVerticeOrigem.CodigoTipoTaxa == PU &&
                         codigoTipoTaxaDestino == FATOR_DIARIO)
                {
                    linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverterPUParaFatorDiario(ConverterParaDouble(linha[COLUNA_VALOR_PONTO]));
                }
                else if (tipoVerticeOrigem.CodigoTipoTaxa == TAXA)
                {
                    if (curvaVigenteOrigem.CodigoTipoTaxa == EXPONENCIAL)
                    {
                        if (codigoTipoTaxaDestino == FATOR_DIARIO)
                        {
                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverterTaxaExponencialParaFatorDiario(
                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo),
                                RetornarNumeroDias(curvaVigenteOrigem.CodigoTipoPrazo,
                                ConverterParaInt(linha[COLUNA_DC]),
                                ConverterParaInt(linha[COLUNA_DU])));
                        }
                        else if (codigoTipoTaxaDestino == PU)
                        {
                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverterTaxaExponencialParaPU(
                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo),
                                RetornarNumeroDias(curvaVigenteOrigem.CodigoTipoPrazo,
                                ConverterParaInt(linha[COLUNA_DC]),
                                ConverterParaInt(linha[COLUNA_DU])));
                        }
                        else if (codigoTipoTaxaDestino == TAXA &&
                                 codigoTipoBaseDestino != curvaVigenteOrigem.CodigoTipoPrazo)
                        {
                            if (curvaVigenteOrigem.CodigoTipoPrazo == BASE_DU252)
                            {
                                if (codigoTipoBaseDestino != BASE_DU252)
                                {
                                    if (ValidarCurvaPMT(curvaVigenteOrigem))
                                    {
                                        if (linha[COLUNA_DC_DURATION] != DBNull.Value &&
                                            linha[COLUNA_DU_DURATION] != DBNull.Value)
                                        {
                                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDUParaBaseDC(
                                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                                ConverterParaDouble(linha[COLUNA_DC_DURATION]),
                                                ConverterParaDouble(linha[COLUNA_DU_DURATION]),
                                                RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo));
                                        }
                                    }
                                    else
                                    {
                                        linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDUParaBaseDC(
                                            ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                            ConverterParaDouble(linha[COLUNA_DC]),
                                            ConverterParaDouble(linha[COLUNA_DU]),
                                            RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo));
                                    }
                                }
                            }
                            else
                            {
                                if (codigoTipoBaseDestino == BASE_DU252)
                                {
                                    if (ValidarCurvaPMT(curvaVigenteOrigem))
                                    {
                                        if (linha[COLUNA_DC_DURATION] != DBNull.Value &&
                                            linha[COLUNA_DU_DURATION] != DBNull.Value)
                                        {
                                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDCParaBaseDU(
                                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                                ConverterParaDouble(linha[COLUNA_DC_DURATION]),
                                                ConverterParaDouble(linha[COLUNA_DU_DURATION]),
                                                RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo));
                                        }
                                    }
                                    else
                                    {
                                        linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDCParaBaseDU(
                                            ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                            ConverterParaDouble(linha[COLUNA_DC]),
                                            ConverterParaDouble(linha[COLUNA_DU]),
                                            RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo));
                                    }
                                }
                                else
                                {
                                    linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDCParaBaseDC(
                                        ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                        RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo),
                                        RetornarDiasAnoPorTipoBase(codigoTipoBaseDestino));
                                }
                            }
                        }
                    }
                    else if (curvaVigenteOrigem.CodigoTipoTaxa == LINEAR)
                    {
                        if (codigoTipoTaxaDestino == FATOR_DIARIO)
                        {
                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverterTaxaLinearParaFatorDiario(
                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo),
                                RetornarNumeroDias(curvaVigenteOrigem.CodigoTipoPrazo,
                                ConverterParaInt(linha[COLUNA_DC]),
                                ConverterParaInt(linha[COLUNA_DU])));
                        }
                        else if (codigoTipoTaxaDestino == PU)
                        {
                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverterTaxaLinearParaPU(
                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo),
                                RetornarNumeroDias(curvaVigenteOrigem.CodigoTipoPrazo,
                                ConverterParaInt(linha[COLUNA_DC]),
                                ConverterParaInt(linha[COLUNA_DU])));
                        }
                        else if (codigoTipoTaxaDestino == TAXA &&
                                 codigoTipoBaseDestino != curvaVigenteOrigem.CodigoTipoPrazo)
                        {
                            if (curvaVigenteOrigem.CodigoTipoPrazo == BASE_DU252)
                            {
                                if (codigoTipoBaseDestino != BASE_DU252)
                                {
                                    if (ValidarCurvaPMT(curvaVigenteOrigem))
                                    {
                                        if (linha[COLUNA_DC_DURATION] != DBNull.Value &&
                                            linha[COLUNA_DU_DURATION] != DBNull.Value)
                                        {
                                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDUParaBaseDC(
                                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                                ConverterParaDouble(linha[COLUNA_DC_DURATION]),
                                                ConverterParaDouble(linha[COLUNA_DU_DURATION]),
                                                RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo));
                                        }
                                    }
                                    else
                                    {
                                        linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDUParaBaseDC(
                                            ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                            ConverterParaDouble(linha[COLUNA_DC]),
                                            ConverterParaDouble(linha[COLUNA_DU]),
                                            RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo));
                                    }
                                }
                            }
                            else
                            {
                                if (codigoTipoBaseDestino == BASE_DU252)
                                {
                                    if (ValidarCurvaPMT(curvaVigenteOrigem))
                                    {
                                        if (linha[COLUNA_DC_DURATION] != DBNull.Value &&
                                            linha[COLUNA_DU_DURATION] != DBNull.Value)
                                        {
                                            linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDCParaBaseDU(
                                                ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                                ConverterParaDouble(linha[COLUNA_DC_DURATION]),
                                                ConverterParaDouble(linha[COLUNA_DU_DURATION]),
                                                RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo));
                                        }
                                    }
                                    else
                                    {
                                        linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDCParaBaseDU(
                                            ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                            ConverterParaDouble(linha[COLUNA_DC]),
                                            ConverterParaDouble(linha[COLUNA_DU]),
                                            RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo));
                                    }
                                }
                                else
                                {
                                    linha[COLUNA_VALOR_PONTO] = conversorTaxas.ConverteTaxaBaseDCParaBaseDC(
                                        ConverterParaDouble(linha[COLUNA_VALOR_PONTO]),
                                        RetornarDiasAnoPorTipoBase(curvaVigenteOrigem.CodigoTipoPrazo),
                                        RetornarDiasAnoPorTipoBase(codigoTipoBaseDestino));
                                }
                            }
                        }
                    }
                }
            }
        }

        private bool ValidarCurvaPMT(CurvaVigente curvaVigente)
        {
            return curvaVigente.CodigoCurvaBasePMT != 0;
        }

        private bool ValidarIndexador(Curva curva)
        {
            const int INDEXADOR_CDI = 4;

            return curva.CodigoCategoriaMercado != INDEXADOR_CDI;
        }

        private bool CurvaTemTipoVertice(CurvaVigente curva)
        {
            int VERTICE = 4;

            return (curva != null
                    && curva.lstTaxaPontoCurvaVigente != null
                    && curva.lstTaxaPontoCurvaVigente.Count(t => t.CodigoTipoPontoCurva == VERTICE) > 0);
        }

        private bool ConsultaTrouxeResultado(DataSet ds)
        {
            return (ds != null
                    && ds.Tables.Count > 0
                    && ds.Tables[0].Rows.Count > 0);
        }

        private int ConverterParaInt(object valor)
        {
            return Convert.ToInt32(valor);
        }

        private double ConverterParaDouble(object valor)
        {
            return Convert.ToDouble(valor);
        }

        private int RetornarNumeroDias(int codigoTipoBase, object diasCorridos, object diasUteis)
        {
            int tipoBase252 = 1;

            if (codigoTipoBase == tipoBase252)
            {
                return ConverterParaInt(diasUteis);
            }
            else
            {
                return ConverterParaInt(diasCorridos);
            }
        }

        private int RetornarDiasAnoPorTipoBase(int codigoTipoBase)
        {
            int tipoBase252 = 1;
            int tipoBase360 = 2;

            if (codigoTipoBase == tipoBase252)
            {
                return 252;
            }
            else if (codigoTipoBase == tipoBase360)
            {
                return 360;
            }
            else
            {
                return 30;
            }
        }

        public IList<AnaliseCurvaRetida> ObterListaAnaliseCurvaRetida(CurvaVigente curvaVigente, int situacaoExecucaoAtual)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;
            ICurvaDAO curvaDAO;
            Curva curva = null;
            RegistroExecucaoCurva registroExecucaoCurvaAnteriorLiberada = null;
            RegistroExecucaoCurva registroExecucaoCurvaAnteriorVerticesCorrigidos = null;

            RegistroExecucaoCurva registroExecucaoCurva = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                curvaDAO = DaoFactory.getCurvaDAO();
                curva = new Curva();

                if (curvaVigente.RegistroExecucaoCurva.Count > 0)
                {
                    registroExecucaoCurva = execucaoCurvaDAO.ObterRegistroExecucaoCurva(curvaVigente.CodigoCurvaVigente, curvaVigente.RegistroExecucaoCurva[0].DataInclusaoVigencia, curvaVigente.RegistroExecucaoCurva[0].DataHoraExecucaoCurva);
                    registroExecucaoCurvaAnteriorLiberada = execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curvaVigente.CodigoCurvaVigente, curvaVigente.RegistroExecucaoCurva[0].DataInclusaoVigencia, curvaVigente.RegistroExecucaoCurva[0].DataHoraExecucaoCurva, LIBERADA);
                    registroExecucaoCurvaAnteriorVerticesCorrigidos = execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curvaVigente.CodigoCurvaVigente, curvaVigente.RegistroExecucaoCurva[0].DataInclusaoVigencia, curvaVigente.RegistroExecucaoCurva[0].DataHoraExecucaoCurva, VERTICES_CORRIGIDOS);
                }
                else
                {
                    registroExecucaoCurva = execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curvaVigente.CodigoCurvaVigente, curvaVigente.DataInclusao, DateTime.Now, situacaoExecucaoAtual);
                    registroExecucaoCurvaAnteriorLiberada = execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curvaVigente.CodigoCurvaVigente, curvaVigente.DataInclusao, DateTime.Now, LIBERADA);
                    registroExecucaoCurvaAnteriorVerticesCorrigidos = execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curvaVigente.CodigoCurvaVigente, curvaVigente.DataInclusao, DateTime.Now, VERTICES_CORRIGIDOS);
                }

                registroExecucaoCurva.CurvaExecucaoPonto = execucaoCurvaDAO.ObterCurvaExecucaoPontosAnaliseRetida(
                    registroExecucaoCurva.CodigoCurva,
                    registroExecucaoCurva.DataInclusaoVigencia,
                    registroExecucaoCurva.DataHoraExecucaoCurva);

                curva = curvaDAO.ObterCurva(curvaVigente.CodigoCurvaVigente);

                curva.CurvaVigente = curvaVigente;
                curva.CurvaVigente.RegistroExecucaoCurva = new List<RegistroExecucaoCurva>();
                curva.CurvaVigente.RegistroExecucaoCurva.Add(registroExecucaoCurva);

                return MontarTunel(curva, registroExecucaoCurvaAnteriorLiberada, registroExecucaoCurvaAnteriorVerticesCorrigidos);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
                curvaDAO = null;
                curva = null;
                registroExecucaoCurva = null;
            }

            return new List<AnaliseCurvaRetida>();
        }

        private static IList<AnaliseCurvaRetida> MontarTunel(Curva curva, RegistroExecucaoCurva registroExecucaoCurvaAnteriorLiberada, RegistroExecucaoCurva registroExecucaoCurvaAnteriorVerticesCorrigidos)
        {
            ICurvaBS curvaBS = new CurvaBS();
            int antepolacaoID = 0, interpolacaoID = 0, extrapolacaoID = 0, tipoVerticeID = 0, tipoPrazo = 0;
            IList<TipoPrazo> tiposPrazo = null;
            ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();
            IList<ParametroModeloIntervaloTolerancia> parametroModeloIntervaloTolerancia = null;
            IList<CurvaExecucaoPonto> limiteInferior = new List<CurvaExecucaoPonto>();
            IList<CurvaExecucaoPonto> limiteSuperior = new List<CurvaExecucaoPonto>();
            IList<AnaliseCurvaRetida> listaAnaliseCurvaRetida = new List<AnaliseCurvaRetida>();
            RegistroExecucaoCurva registroExecucaoCurvaAnterior = null;
            IList<CurvaExecucaoPonto> pontosLimiteSuperior = null;
            IList<CurvaExecucaoPonto> pontosLimiteInferior = null;
            AnaliseCurvaRetida analiseCurvaRetida;

            if (registroExecucaoCurvaAnteriorLiberada != null || registroExecucaoCurvaAnteriorVerticesCorrigidos != null)
            {
                registroExecucaoCurvaAnterior = RetornarExecucaoAnterior(registroExecucaoCurvaAnteriorLiberada, registroExecucaoCurvaAnteriorVerticesCorrigidos);

                if (registroExecucaoCurvaAnterior.CurvaExecucaoPonto.Count > 0 && curva.CurvaVigente.CodigoModeloIntervaloTolerancia != 0)
                {
                    parametroModeloIntervaloTolerancia = curvaDAO.ObterParametrosModeloIntervaloTolerancia(curva.CurvaVigente.CodigoModeloIntervaloTolerancia);

                    if (parametroModeloIntervaloTolerancia.Count == 0)
                        return null;

                    curvaBS.ConverterParametroModeloIntervaloToleranciaEmVertice(parametroModeloIntervaloTolerancia, registroExecucaoCurvaAnterior.DataHoraExecucaoCurva, limiteInferior, limiteSuperior, registroExecucaoCurvaAnterior.CurvaExecucaoPonto);
                    tiposPrazo = curvaDAO.ObterTiposPrazo();

                    foreach (TaxaPontoCurvaVigente item in curva.CurvaVigente.lstTaxaPontoCurvaVigente)
                    {
                        switch (item.CodigoTipoPontoCurva)
                        {
                            case ANTEPOLACAO:
                                antepolacaoID = item.CodigoTipoTaxa;
                                break;
                            case INTERPOLACAO:
                                interpolacaoID = item.CodigoTipoTaxa;
                                break;
                            case EXTRAPOLACAO:
                                extrapolacaoID = item.CodigoTipoTaxa;
                                break;
                            case TIPO_VERTICE:
                                tipoVerticeID = item.CodigoTipoTaxa;
                                break;
                        }
                    }

                    if (curva.CurvaVigente.CodigoTipoEntradaDado.Equals(TIPO_COMPOSTA))
                    {
                        antepolacaoID = 2;
                        interpolacaoID = 2;
                        extrapolacaoID = 2;
                    }

                    if (curva.CurvaVigente.CodigoTipoEntradaDado.Equals(TIPO_COMPOSTA)
                        && curva.CurvaVigente.ComposicaoCurva.Itens.Count > 0)
                    {
                        List<Curva> itensComposicaoCurva = new List<Curva>();

                        foreach (ItemComposicao item in curva.CurvaVigente.ComposicaoCurva.Itens)
                        {
                            Curva curvaItemComposicao = curvaDAO.ObterCurva(item.CodigoCurvaIntegrante);
                            itensComposicaoCurva.Add(curvaItemComposicao);
                        }

                        int quantidadeTiposPrazosDistintos = (from a in itensComposicaoCurva
                                                              select a.CurvaVigente.CodigoTipoPrazo).Distinct().Count();

                        if (quantidadeTiposPrazosDistintos.Equals(1))
                        {
                            tipoPrazo = (tiposPrazo.FirstOrDefault(x => x.Codigo.Equals(itensComposicaoCurva[0].CurvaVigente.CodigoTipoPrazo)) ?? new TipoPrazo()).QuantidadeDiasAno;
                        }
                        else
                        {
                            tipoPrazo = 365;
                        }
                    }
                    else
                    {
                        tipoPrazo = (tiposPrazo.FirstOrDefault(x => x.Codigo.Equals(curva.CurvaVigente.CodigoTipoPrazo)) ?? new TipoPrazo()).QuantidadeDiasAno;
                    }

                    double taxaOver = limiteInferior[0].ValorVertice;

                    int qtdDiasCorridosLimSup = limiteSuperior.Last().QuantidadeDiasCorridos;
                    int qtdDiasCorridosCurvaAnt = registroExecucaoCurvaAnterior.CurvaExecucaoPonto.Last().QuantidadeDiasCorridos;
                    int qtdDiasCorridos;

                    if (qtdDiasCorridosCurvaAnt > qtdDiasCorridosLimSup)
                        qtdDiasCorridos = qtdDiasCorridosCurvaAnt;
                    else
                        qtdDiasCorridos = qtdDiasCorridosLimSup;

                    DateTime DataFinalVertices = curva.CurvaVigente.DataInclusao.AddDays(qtdDiasCorridos);
                    CalendarioReguaBS calRegua = new CalendarioReguaBS(curva.CurvaVigente.DataInclusao, DataFinalVertices);
                    Interpolador interpoladorBS = new Interpolador();

                    pontosLimiteInferior = interpoladorBS.InterpolarTunel(limiteInferior, taxaOver, curva.CurvaVigente.DataInclusao, qtdDiasCorridos, antepolacaoID, interpolacaoID, extrapolacaoID, tipoPrazo, tipoVerticeID);
                    pontosLimiteSuperior = interpoladorBS.InterpolarTunel(limiteSuperior, taxaOver, curva.CurvaVigente.DataInclusao, qtdDiasCorridos, antepolacaoID, interpolacaoID, extrapolacaoID, tipoPrazo, tipoVerticeID);
                }
            }

            for (int i = 0; i < curva.CurvaVigente.RegistroExecucaoCurva[0].CurvaExecucaoPonto.Count; i++)
            {
                analiseCurvaRetida = new AnaliseCurvaRetida();

                analiseCurvaRetida.CurvaID = curva.CurvaVigente.CodigoCurvaVigente;
                analiseCurvaRetida.DataInclusaoVigencia = curva.CurvaVigente.DataInclusao;
                analiseCurvaRetida.DataHoraExecucaoCurva = curva.CurvaVigente.RegistroExecucaoCurva[0].DataHoraExecucaoCurva;
                analiseCurvaRetida.Vencimento = curva.CurvaVigente.RegistroExecucaoCurva[0].CurvaExecucaoPonto[i].DataVencimento;
                analiseCurvaRetida.DiasUteis = curva.CurvaVigente.RegistroExecucaoCurva[0].CurvaExecucaoPonto[i].QuantidadeDiasUteis;
                analiseCurvaRetida.DiasCorridos = curva.CurvaVigente.RegistroExecucaoCurva[0].CurvaExecucaoPonto[i].QuantidadeDiasCorridos;
                analiseCurvaRetida.ValorVertice = curva.CurvaVigente.RegistroExecucaoCurva[0].CurvaExecucaoPonto[i].ValorVertice;

                if (pontosLimiteInferior != null &&
                    pontosLimiteSuperior != null &&
                    registroExecucaoCurvaAnterior.CurvaExecucaoPonto.Count > 0)
                {
                    CurvaExecucaoPonto toleranciaSuperior = pontosLimiteSuperior.FirstOrDefault(p => p.QuantidadeDiasCorridos == curva.CurvaVigente.RegistroExecucaoCurva[0].CurvaExecucaoPonto[i].QuantidadeDiasCorridos);
                    CurvaExecucaoPonto toleranciaInferior = pontosLimiteInferior.FirstOrDefault(p => p.QuantidadeDiasCorridos == curva.CurvaVigente.RegistroExecucaoCurva[0].CurvaExecucaoPonto[i].QuantidadeDiasCorridos);
                    CurvaExecucaoPonto pontoCurvaAnterior = registroExecucaoCurvaAnterior.CurvaExecucaoPonto.FirstOrDefault(p => p.QuantidadeDiasCorridos == curva.CurvaVigente.RegistroExecucaoCurva[0].CurvaExecucaoPonto[i].QuantidadeDiasCorridos);

                    if (pontoCurvaAnterior != null)
                    {
                        if (toleranciaSuperior != null)
                        {
                            analiseCurvaRetida.TunelamentoMax = toleranciaSuperior.ValorVertice * pontoCurvaAnterior.ValorVertice;
                        }

                        if (toleranciaInferior != null)
                        {
                            analiseCurvaRetida.TunelamentoMin = toleranciaInferior.ValorVertice * pontoCurvaAnterior.ValorVertice;
                        }
                    }
                }

                analiseCurvaRetida.IndicadorVertice = curva.CurvaVigente.RegistroExecucaoCurva[0].CurvaExecucaoPonto[i].IndicadorVertice;

                listaAnaliseCurvaRetida.Add(analiseCurvaRetida);
            }

            return listaAnaliseCurvaRetida;
        }

        private static RegistroExecucaoCurva RetornarExecucaoAnterior(RegistroExecucaoCurva registroExecucaoCurvaAnteriorLiberada, RegistroExecucaoCurva registroExecucaoCurvaAnteriorVerticesCorrigidos)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
            RegistroExecucaoCurva registroExecucaoCurvaAnterior = null;

            if (registroExecucaoCurvaAnteriorLiberada == null && registroExecucaoCurvaAnteriorVerticesCorrigidos != null)
            {
                registroExecucaoCurvaAnterior = registroExecucaoCurvaAnteriorVerticesCorrigidos;
            }
            else if (registroExecucaoCurvaAnteriorVerticesCorrigidos == null && registroExecucaoCurvaAnteriorLiberada != null)
            {
                registroExecucaoCurvaAnterior = registroExecucaoCurvaAnteriorLiberada;
            }
            else if (registroExecucaoCurvaAnteriorVerticesCorrigidos.DataHoraExecucaoCurva > registroExecucaoCurvaAnteriorLiberada.DataHoraExecucaoCurva)
            {
                registroExecucaoCurvaAnterior = registroExecucaoCurvaAnteriorVerticesCorrigidos;
            }
            else
            {
                registroExecucaoCurvaAnterior = registroExecucaoCurvaAnteriorLiberada;
            }

            registroExecucaoCurvaAnterior.CurvaExecucaoPonto = execucaoCurvaDAO.ObterCurvaExecucaoPontosAnaliseRetida(registroExecucaoCurvaAnterior.CodigoCurva, registroExecucaoCurvaAnterior.DataInclusaoVigencia, registroExecucaoCurvaAnterior.DataHoraExecucaoCurva);

            return registroExecucaoCurvaAnterior;
        }

        public IList<AnaliseCurvaRetida> ObterListaAnaliseCurvaRetidaPaginada(CurvaVigente curvaVigente, int situacaoExecucaoAtual, int pagina)
        {
            try
            {
                return PaginarLista<AnaliseCurvaRetida>(ObterListaAnaliseCurvaRetida(curvaVigente, situacaoExecucaoAtual), pagina);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return new List<AnaliseCurvaRetida>();
        }

        private IList<T> PaginarLista<T>(IList<T> iList, int pagina)
        {
            int tamanhoPagina = 14600;

            if (pagina > 1)
            {
                int registros = (pagina - 1) * tamanhoPagina;
                T[] listaJaVista = iList.Take(registros).ToArray<T>();

                foreach (T analise in listaJaVista)
                {
                    iList.Remove(analise);
                }
            }

            return iList.Take(tamanhoPagina).ToList<T>();
        }

        public IList<AnaliseCurvaRetida> ObterListaAnaliseCurvaRetida(Curva curva)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;
            ICurvaDAO curvaDAO;
            RegistroExecucaoCurva registroExecucaoCurvaAnteriorLiberada = null;
            RegistroExecucaoCurva registroExecucaoCurvaAnteriorVerticesCorrigidos = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();
                curvaDAO = DaoFactory.getCurvaDAO();

                if (curva.CurvaVigente.RegistroExecucaoCurva.Count > 0)
                {
                    registroExecucaoCurvaAnteriorLiberada = execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curva.CurvaVigente.CodigoCurvaVigente, curva.CurvaVigente.RegistroExecucaoCurva[0].DataInclusaoVigencia, curva.CurvaVigente.RegistroExecucaoCurva[0].DataHoraExecucaoCurva, LIBERADA);
                    registroExecucaoCurvaAnteriorVerticesCorrigidos = execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curva.CurvaVigente.CodigoCurvaVigente, curva.CurvaVigente.RegistroExecucaoCurva[0].DataInclusaoVigencia, curva.CurvaVigente.RegistroExecucaoCurva[0].DataHoraExecucaoCurva, VERTICES_CORRIGIDOS);
                }
                else
                {
                    registroExecucaoCurvaAnteriorLiberada = execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curva.CurvaVigente.CodigoCurvaVigente, curva.CurvaVigente.DataInclusao, DateTime.Now, LIBERADA);
                    registroExecucaoCurvaAnteriorVerticesCorrigidos = execucaoCurvaDAO.ObterUltimaExecucaoCurvaVigente(curva.CurvaVigente.CodigoCurvaVigente, curva.CurvaVigente.DataInclusao, DateTime.Now, VERTICES_CORRIGIDOS);
                }

                return MontarTunel(curva, registroExecucaoCurvaAnteriorLiberada, registroExecucaoCurvaAnteriorVerticesCorrigidos);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
                curvaDAO = null;
                curva = null;
            }

            return new List<AnaliseCurvaRetida>();
        }

        private bool ValidarCurva(RegistroExecucaoCurva registroExecucaoCurva, Curva curva)
        {
            IList<AnaliseCurvaRetida> listaCurvaRetida = null;
            bool valido = false;

            curva.CurvaVigente.RegistroExecucaoCurva = new List<RegistroExecucaoCurva>();
            curva.CurvaVigente.RegistroExecucaoCurva.Add(registroExecucaoCurva);

            if (ExisteTunelamentoCadastrado(curva.CurvaVigente))
            {
                listaCurvaRetida = ObterListaAnaliseCurvaRetida(curva);
            }

            if (listaCurvaRetida != null && listaCurvaRetida.Count > 0)
            {
                valido = ValidarCurvaNoTunel(listaCurvaRetida);
            }
            else
            {
                valido = true;
            }

            return valido;
        }

        public void ValidarLiberacaoCurva(RegistroExecucaoCurva registroExecucaoCurva, Curva curva, bool valido)
        {
            if (valido)
            {
                if (curva.IndicadorLiberacaoAutomatica)
                {
                    registroExecucaoCurva.CodigoSituacao = LIBERADA;
                    registroExecucaoCurva.DataHoraLiberacaoCurva = DateTime.Now;
                    AtualizarRegistroExecucaoCurva(registroExecucaoCurva);
                }
                else
                {
                    registroExecucaoCurva.CodigoSituacao = AGUARDANDO_LIBERACAO;
                    AtualizarRegistroExecucaoCurva(registroExecucaoCurva);
                }
            }
            else
            {
                registroExecucaoCurva.CodigoSituacao = RETIDA;
                AtualizarRegistroExecucaoCurva(registroExecucaoCurva);
            }
        }

        public bool ValidarCurvaExecucao(Curva curva, RegistroExecucaoCurva registroExecucaoCurva)
        {
            try
            {
                return ValidarCurva(registroExecucaoCurva, curva);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return false;
        }

        private bool ExisteTunelamentoCadastrado(CurvaVigente objCurvaVigente)
        {
            return objCurvaVigente.CodigoModeloIntervaloTolerancia > 0;
        }

        public bool ValidarCurvaNoTunel(IList<AnaliseCurvaRetida> listaCurvaRetida)
        {
            try
            {
                for (int countPonto = 0; countPonto < listaCurvaRetida.Count; countPonto++)
                {
                    if (!(listaCurvaRetida[countPonto].ValorVertice <= listaCurvaRetida[countPonto].TunelamentoMax && listaCurvaRetida[countPonto].ValorVertice >= listaCurvaRetida[countPonto].TunelamentoMin))
                    {
                        return false;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return true;
        }

        public IList<CurvaExecucaoPonto> Dividir(IList<CurvaExecucaoPonto> pontosCurvaA, IList<CurvaExecucaoPonto> pontosCurvaB, string operadorCurvaA, string operadorCurvaB)
        {
            IList<CurvaExecucaoPonto> pontosRetorno = new List<CurvaExecucaoPonto>();

            int tamanhoCurvaA = pontosCurvaA.Count;
            int tamanhoCurvaB = pontosCurvaB.Count;

            int tamanhoCurvaNova = ((tamanhoCurvaA < tamanhoCurvaB) && (tamanhoCurvaA > 0)) ? tamanhoCurvaA : (tamanhoCurvaB > 0) ? tamanhoCurvaB : tamanhoCurvaA;

            CurvaExecucaoPonto curvaExecucaoPonto;

            for (int cont = 0; cont < tamanhoCurvaNova; cont++)
            {
                curvaExecucaoPonto = new CurvaExecucaoPonto();
                double valorA;
                double valorB;

                if (!operadorCurvaA.Equals("DU") && !operadorCurvaA.Equals("DC") && !operadorCurvaB.Equals("DU") && !operadorCurvaA.Equals("DC"))
                {
                    CurvaExecucaoPonto curvaA;
                    CurvaExecucaoPonto curvaB;

                    if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                    {
                        curvaB = pontosCurvaB[cont];
                        curvaExecucaoPonto.ValorVertice = (double)valorA / curvaB.ValorVertice;
                        curvaExecucaoPonto.DataVencimento = curvaB.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaB.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaB.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaB.IndicadorVertice;
                    }
                    else if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaExecucaoPonto.ValorVertice = (double)curvaA.ValorVertice / valorB;
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                    else
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaB = pontosCurvaB.Single(c => c.QuantidadeDiasCorridos == curvaA.QuantidadeDiasCorridos);
                        curvaExecucaoPonto.ValorVertice = (double)curvaA.ValorVertice / curvaB.ValorVertice;
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                }
                else if (operadorCurvaA.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaA.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasUteis / valorB;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasUteis / pontosCurvaB[cont].ValorVertice;
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasCorridos / valorB;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasCorridos / pontosCurvaB[cont].ValorVertice;
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaA[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaA[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaA[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaA[cont].IndicadorVertice;
                }
                else if (operadorCurvaB.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaB.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)valorA / pontosCurvaB[cont].QuantidadeDiasUteis;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].ValorVertice / pontosCurvaB[cont].QuantidadeDiasUteis;
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)valorA / pontosCurvaB[cont].QuantidadeDiasCorridos;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].ValorVertice / pontosCurvaB[cont].QuantidadeDiasCorridos;
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaB[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaB[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaB[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaB[cont].IndicadorVertice;
                }

                pontosRetorno.Add(curvaExecucaoPonto);
            }

            return pontosRetorno;
        }

        private bool ConverterValorParaDouble(string operadorCurvaA, out double valorA)
        {
            if (operadorCurvaA.Contains("#"))
            {
                return Double.TryParse(operadorCurvaA.Replace("#", "-"), out valorA);
            }
            else
            {
                return Double.TryParse(operadorCurvaA, out valorA);
            }
        }

        public IList<CurvaExecucaoPonto> Somar(IList<CurvaExecucaoPonto> pontosCurvaA, IList<CurvaExecucaoPonto> pontosCurvaB, string operadorCurvaA, string operadorCurvaB)
        {
            IList<CurvaExecucaoPonto> pontosRetorno = new List<CurvaExecucaoPonto>();

            int tamanhoCurvaA = pontosCurvaA.Count;
            int tamanhoCurvaB = pontosCurvaB.Count;

            int tamanhoCurvaNova = ((tamanhoCurvaA < tamanhoCurvaB) && (tamanhoCurvaA > 0)) ? tamanhoCurvaA : (tamanhoCurvaB > 0) ? tamanhoCurvaB : tamanhoCurvaA;

            CurvaExecucaoPonto curvaExecucaoPonto;

            for (int cont = 0; cont < tamanhoCurvaNova; cont++)
            {
                curvaExecucaoPonto = new CurvaExecucaoPonto();
                double valorA;
                double valorB;

                if (!operadorCurvaA.Equals("DU") && !operadorCurvaA.Equals("DC") && !operadorCurvaB.Equals("DU") && !operadorCurvaA.Equals("DC"))
                {
                    CurvaExecucaoPonto curvaA;
                    CurvaExecucaoPonto curvaB;

                    if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                    {
                        curvaB = pontosCurvaB[cont];
                        curvaExecucaoPonto.ValorVertice = (double)valorA + curvaB.ValorVertice;
                        curvaExecucaoPonto.DataVencimento = curvaB.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaB.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaB.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaB.IndicadorVertice;
                    }
                    else if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaExecucaoPonto.ValorVertice = (double)curvaA.ValorVertice + valorB;
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                    else
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaB = pontosCurvaB.Single(c => c.QuantidadeDiasCorridos == curvaA.QuantidadeDiasCorridos);
                        curvaExecucaoPonto.ValorVertice = (double)curvaA.ValorVertice + curvaB.ValorVertice;
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                }
                else if (operadorCurvaA.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaA.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasUteis + valorB;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasUteis + pontosCurvaB[cont].ValorVertice;
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasCorridos + valorB;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasCorridos + pontosCurvaB[cont].ValorVertice;
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaA[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaA[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaA[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaA[cont].IndicadorVertice;
                }
                else if (operadorCurvaB.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaB.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)valorA + pontosCurvaB[cont].QuantidadeDiasUteis;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].ValorVertice + pontosCurvaB[cont].QuantidadeDiasUteis;
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)valorA + pontosCurvaB[cont].QuantidadeDiasCorridos;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].ValorVertice + pontosCurvaB[cont].QuantidadeDiasCorridos;
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaB[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaB[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaB[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaB[cont].IndicadorVertice;
                }

                pontosRetorno.Add(curvaExecucaoPonto);
            }

            return pontosRetorno;
        }

        public IList<CurvaExecucaoPonto> Potencia(IList<CurvaExecucaoPonto> pontosCurvaA, IList<CurvaExecucaoPonto> pontosCurvaB, string operadorCurvaA, string operadorCurvaB)
        {
            IList<CurvaExecucaoPonto> pontosRetorno = new List<CurvaExecucaoPonto>();

            int tamanhoCurvaA = pontosCurvaA.Count;
            int tamanhoCurvaB = pontosCurvaB.Count;

            int tamanhoCurvaNova = ((tamanhoCurvaA < tamanhoCurvaB) && (tamanhoCurvaA > 0)) ? tamanhoCurvaA : (tamanhoCurvaB > 0) ? tamanhoCurvaB : tamanhoCurvaA;

            CurvaExecucaoPonto curvaExecucaoPonto;

            for (int cont = 0; cont < tamanhoCurvaNova; cont++)
            {
                curvaExecucaoPonto = new CurvaExecucaoPonto();
                double valorA;
                double valorB;

                if (!operadorCurvaA.Equals("DU") && !operadorCurvaA.Equals("DC") && !operadorCurvaB.Equals("DU") && !operadorCurvaA.Equals("DC"))
                {
                    CurvaExecucaoPonto curvaA;
                    CurvaExecucaoPonto curvaB;

                    if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                    {
                        curvaB = pontosCurvaB[cont];
                        curvaExecucaoPonto.ValorVertice = Math.Pow(valorA, curvaB.ValorVertice);
                        curvaExecucaoPonto.DataVencimento = curvaB.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaB.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaB.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaB.IndicadorVertice;
                    }
                    else if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaExecucaoPonto.ValorVertice = Math.Pow(curvaA.ValorVertice, valorB);
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                    else
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaB = pontosCurvaB.Single(c => c.QuantidadeDiasCorridos == curvaA.QuantidadeDiasCorridos);
                        curvaExecucaoPonto.ValorVertice = Math.Pow(curvaA.ValorVertice, curvaB.ValorVertice);
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                }
                else if (operadorCurvaA.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaA.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = Math.Pow(pontosCurvaA[cont].QuantidadeDiasUteis, valorB);
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = Math.Pow(pontosCurvaA[cont].QuantidadeDiasUteis, pontosCurvaB[cont].ValorVertice);
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = Math.Pow(pontosCurvaA[cont].QuantidadeDiasCorridos, valorB);
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = Math.Pow(pontosCurvaA[cont].QuantidadeDiasCorridos, pontosCurvaB[cont].ValorVertice);
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaA[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaA[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaA[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaA[cont].IndicadorVertice;
                }
                else if (operadorCurvaB.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaB.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = Math.Pow(valorA, pontosCurvaB[cont].QuantidadeDiasUteis);
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = Math.Pow(pontosCurvaA[cont].ValorVertice, pontosCurvaB[cont].QuantidadeDiasUteis);
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = Math.Pow(valorA, pontosCurvaB[cont].QuantidadeDiasCorridos);
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = Math.Pow(pontosCurvaA[cont].ValorVertice, pontosCurvaB[cont].QuantidadeDiasCorridos);
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaB[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaB[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaB[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaB[cont].IndicadorVertice;
                }

                pontosRetorno.Add(curvaExecucaoPonto);
            }

            return pontosRetorno;
        }

        public IList<CurvaExecucaoPonto> Subtrair(IList<CurvaExecucaoPonto> pontosCurvaA, IList<CurvaExecucaoPonto> pontosCurvaB, string operadorCurvaA, string operadorCurvaB)
        {
            IList<CurvaExecucaoPonto> pontosRetorno = new List<CurvaExecucaoPonto>();

            int tamanhoCurvaA = pontosCurvaA.Count;
            int tamanhoCurvaB = pontosCurvaB.Count;

            int tamanhoCurvaNova = ((tamanhoCurvaA < tamanhoCurvaB) && (tamanhoCurvaA > 0)) ? tamanhoCurvaA : (tamanhoCurvaB > 0) ? tamanhoCurvaB : tamanhoCurvaA;

            CurvaExecucaoPonto curvaExecucaoPonto;

            for (int cont = 0; cont < tamanhoCurvaNova; cont++)
            {
                curvaExecucaoPonto = new CurvaExecucaoPonto();
                double valorA;
                double valorB;

                if (!operadorCurvaA.Equals("DU") && !operadorCurvaA.Equals("DC") && !operadorCurvaB.Equals("DU") && !operadorCurvaA.Equals("DC"))
                {
                    CurvaExecucaoPonto curvaA;
                    CurvaExecucaoPonto curvaB;

                    if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                    {
                        curvaB = pontosCurvaB[cont];
                        curvaExecucaoPonto.ValorVertice = (double)valorA - curvaB.ValorVertice;
                        curvaExecucaoPonto.DataVencimento = curvaB.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaB.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaB.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaB.IndicadorVertice;
                    }
                    else if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaExecucaoPonto.ValorVertice = (double)curvaA.ValorVertice - valorB;
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                    else
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaB = pontosCurvaB.Single(c => c.QuantidadeDiasCorridos == curvaA.QuantidadeDiasCorridos);
                        curvaExecucaoPonto.ValorVertice = (double)curvaA.ValorVertice - curvaB.ValorVertice;
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                }
                else if (operadorCurvaA.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaA.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasUteis - valorB;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasUteis - pontosCurvaB[cont].ValorVertice;
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasCorridos - valorB;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasCorridos - pontosCurvaB[cont].ValorVertice;
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaA[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaA[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaA[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaA[cont].IndicadorVertice;
                }
                else if (operadorCurvaB.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaB.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)valorA - pontosCurvaB[cont].QuantidadeDiasUteis;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].ValorVertice - pontosCurvaB[cont].QuantidadeDiasUteis;
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)valorA - pontosCurvaB[cont].QuantidadeDiasCorridos;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].ValorVertice - pontosCurvaB[cont].QuantidadeDiasCorridos;
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaB[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaB[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaB[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaB[cont].IndicadorVertice;
                }

                pontosRetorno.Add(curvaExecucaoPonto);
            }

            return pontosRetorno;
        }

        public IList<CurvaExecucaoPonto> Multiplicar(IList<CurvaExecucaoPonto> pontosCurvaA, IList<CurvaExecucaoPonto> pontosCurvaB, string operadorCurvaA, string operadorCurvaB)
        {
            IList<CurvaExecucaoPonto> pontosRetorno = new List<CurvaExecucaoPonto>();

            int tamanhoCurvaA = pontosCurvaA.Count;
            int tamanhoCurvaB = pontosCurvaB.Count;

            int tamanhoCurvaNova = ((tamanhoCurvaA < tamanhoCurvaB) && (tamanhoCurvaA > 0)) ? tamanhoCurvaA : (tamanhoCurvaB > 0) ? tamanhoCurvaB : tamanhoCurvaA;

            CurvaExecucaoPonto curvaExecucaoPonto;

            for (int cont = 0; cont < tamanhoCurvaNova; cont++)
            {
                curvaExecucaoPonto = new CurvaExecucaoPonto();
                double valorA;
                double valorB;

                if (!operadorCurvaA.Equals("DU") && !operadorCurvaA.Equals("DC") && !operadorCurvaB.Equals("DU") && !operadorCurvaA.Equals("DC"))
                {
                    CurvaExecucaoPonto curvaA;
                    CurvaExecucaoPonto curvaB;

                    if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                    {
                        curvaB = pontosCurvaB[cont];
                        curvaExecucaoPonto.ValorVertice = (double)valorA * curvaB.ValorVertice;
                        curvaExecucaoPonto.DataVencimento = curvaB.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaB.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaB.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaB.IndicadorVertice;
                    }
                    else if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaExecucaoPonto.ValorVertice = (double)curvaA.ValorVertice * valorB;
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                    else
                    {
                        curvaA = pontosCurvaA[cont];
                        curvaB = pontosCurvaB.Single(c => c.QuantidadeDiasCorridos == curvaA.QuantidadeDiasCorridos);
                        curvaExecucaoPonto.ValorVertice = (double)curvaA.ValorVertice * curvaB.ValorVertice;
                        curvaExecucaoPonto.DataVencimento = curvaA.DataVencimento;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = curvaA.QuantidadeDiasCorridos;
                        curvaExecucaoPonto.QuantidadeDiasUteis = curvaA.QuantidadeDiasUteis;
                        curvaExecucaoPonto.IndicadorVertice = curvaA.IndicadorVertice;
                    }
                }
                else if (operadorCurvaA.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaA.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasUteis * valorB;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasUteis * pontosCurvaB[cont].ValorVertice;
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaB, out valorB))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasCorridos * valorB;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].QuantidadeDiasCorridos * pontosCurvaB[cont].ValorVertice;
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaA[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaA[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaA[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaA[cont].IndicadorVertice;
                }
                else if (operadorCurvaB.Equals("DU") || operadorCurvaA.Equals("DC"))
                {
                    if (operadorCurvaB.Equals("DU"))
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)valorA * pontosCurvaB[cont].QuantidadeDiasUteis;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].ValorVertice * pontosCurvaB[cont].QuantidadeDiasUteis;
                        }
                    }
                    else
                    {
                        if (ConverterValorParaDouble(operadorCurvaA, out valorA))
                        {
                            curvaExecucaoPonto.ValorVertice = (double)valorA * pontosCurvaB[cont].QuantidadeDiasCorridos;
                        }
                        else
                        {
                            curvaExecucaoPonto.ValorVertice = (double)pontosCurvaA[cont].ValorVertice * pontosCurvaB[cont].QuantidadeDiasCorridos;
                        }
                    }

                    curvaExecucaoPonto.DataVencimento = pontosCurvaB[cont].DataVencimento;
                    curvaExecucaoPonto.QuantidadeDiasCorridos = pontosCurvaB[cont].QuantidadeDiasCorridos;
                    curvaExecucaoPonto.QuantidadeDiasUteis = pontosCurvaB[cont].QuantidadeDiasUteis;
                    curvaExecucaoPonto.IndicadorVertice = pontosCurvaB[cont].IndicadorVertice;
                }

                pontosRetorno.Add(curvaExecucaoPonto);
            }

            return pontosRetorno;
        }

        public void CriarAgendamentoDasCurvasAtivas(DateTime dataHoraAtual, int codigoSituacao, int codigoTipoEventoNotificacao, DateTime dataHoraLiberacaoCurva)
        {
            IExecucaoCurvaDAO execucaoCurvaDAO;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                execucaoCurvaDAO.CriarAgendamentoDasCurvasAtivas(dataHoraAtual, codigoSituacao, codigoTipoEventoNotificacao, dataHoraLiberacaoCurva);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }
        }

        public void CriarCurvaExecucaoPorImportacao(ImportacaoArquivo importArquivo, RegistroExecucaoCurva registroExecucaoCurva)
        {
            try
            {
                IList<CurvaExecucaoPonto> _listaVertices = new List<CurvaExecucaoPonto>();
                _listaVertices = ImportarVertices(importArquivo, registroExecucaoCurva);

                RegistroExecucaoCurva _novoRegistroExecucaoCurva = new RegistroExecucaoCurva();
                _novoRegistroExecucaoCurva.CodigoCurva = registroExecucaoCurva.CodigoCurva;
                _novoRegistroExecucaoCurva.CodigoSituacao = registroExecucaoCurva.CodigoSituacao;
                _novoRegistroExecucaoCurva.CodigoTipoEventoNotificacao = registroExecucaoCurva.CodigoTipoEventoNotificacao;
                _novoRegistroExecucaoCurva.CodigoUsuarioLiberacao = registroExecucaoCurva.CodigoUsuarioLiberacao;
                _novoRegistroExecucaoCurva.DataHoraExecucaoCurva = registroExecucaoCurva.DataHoraExecucaoCurva;
                _novoRegistroExecucaoCurva.DataHoraLiberacaoCurva = registroExecucaoCurva.DataHoraLiberacaoCurva;
                _novoRegistroExecucaoCurva.DataInclusaoVigencia = registroExecucaoCurva.DataInclusaoVigencia;
                _novoRegistroExecucaoCurva.CurvaExecucaoPonto = new List<CurvaExecucaoPonto>();
                foreach (CurvaExecucaoPonto curvaExecucaoPontoTarefa in _listaVertices)
                {
                    CurvaExecucaoPonto _curvaExecucaoPonto = new CurvaExecucaoPonto();
                    _curvaExecucaoPonto.CodigoCurva = curvaExecucaoPontoTarefa.CodigoCurva;
                    _curvaExecucaoPonto.DataHoraExecucaoCurva = curvaExecucaoPontoTarefa.DataHoraExecucaoCurva;
                    _curvaExecucaoPonto.DataInclusaoVigencia = curvaExecucaoPontoTarefa.DataInclusaoVigencia;
                    _curvaExecucaoPonto.DataVencimento = curvaExecucaoPontoTarefa.DataVencimento;
                    _curvaExecucaoPonto.IndicadorVertice = curvaExecucaoPontoTarefa.IndicadorVertice;
                    _curvaExecucaoPonto.QuantidadeDiasCorridos = curvaExecucaoPontoTarefa.QuantidadeDiasCorridos;
                    _curvaExecucaoPonto.QuantidadeDiasUteis = curvaExecucaoPontoTarefa.QuantidadeDiasUteis;
                    _curvaExecucaoPonto.ValorVertice = curvaExecucaoPontoTarefa.ValorVertice;
                    _novoRegistroExecucaoCurva.CurvaExecucaoPonto.Add(_curvaExecucaoPonto);
                }

                CriarRegistroExecucaoCurva(_novoRegistroExecucaoCurva);
                CriarCurvaExecucaoPontos(_listaVertices);

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

        }

        public const int SIM = 1;

        public IList<CurvaExecucaoPonto> ImportarVertices(ImportacaoArquivo importArquivo, RegistroExecucaoCurva registroExecucaoCurva)
        {
            IList<CurvaExecucaoPonto> listaVertices = new List<CurvaExecucaoPonto>();

            switch (importArquivo.Sigla.ToUpper())
            {
                case "TXT":
                case "CSV":
                    listaVertices = LerArquivoTXTCSV(importArquivo, registroExecucaoCurva);
                    break;

                case "XLS":
                    listaVertices = LerArquivoXLS(importArquivo, registroExecucaoCurva);
                    break;
                case "XLSX":
                    listaVertices = LerArquivoXLSX(importArquivo, registroExecucaoCurva);
                    break;
            }

            return listaVertices;
        }

        private IList<CurvaExecucaoPonto> LerArquivoTXTCSV(ImportacaoArquivo importArquivo, RegistroExecucaoCurva registroExecucaoCurva)
        {
            StreamReader stream = null;
            ICalendarioBS calendario = new CalendarioBS();
            CurvaExecucaoPonto curvaExecucaoPonto = null;
            IList<CurvaExecucaoPonto> listaVertices = new List<CurvaExecucaoPonto>();

            try
            {

                stream = new StreamReader(string.Format("{0}\\{1}", importArquivo.Diretorio, importArquivo.NomeArquivo));

                string linha = null;
                string[] linhaSeparada = null;
                Int32 contLinha = 0;

                while ((linha = stream.ReadLine()) != null)
                {
                    if (contLinha > 0)
                    {
                        curvaExecucaoPonto = new CurvaExecucaoPonto();
                        linhaSeparada = linha.Split(';');

                        curvaExecucaoPonto.CodigoCurva = registroExecucaoCurva.CodigoCurva;
                        curvaExecucaoPonto.DataHoraExecucaoCurva = registroExecucaoCurva.DataHoraExecucaoCurva;
                        curvaExecucaoPonto.DataInclusaoVigencia = registroExecucaoCurva.DataInclusaoVigencia;
                        curvaExecucaoPonto.DataVencimento = registroExecucaoCurva.DataHoraExecucaoCurva.Date.AddDays(Int32.Parse(linhaSeparada[0]));
                        curvaExecucaoPonto.ValorVertice = double.Parse(linhaSeparada[1]);
                        curvaExecucaoPonto.IndicadorVertice = SIM;
                        curvaExecucaoPonto.QuantidadeDiasCorridos = Int32.Parse(linhaSeparada[0]);
                        curvaExecucaoPonto.QuantidadeDiasUteis = calendario.CalcularDiasUteisEntre(registroExecucaoCurva.DataHoraExecucaoCurva, curvaExecucaoPonto.DataVencimento);

                        listaVertices.Add(curvaExecucaoPonto);
                    }

                    contLinha += 1;
                }

                stream.Close();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                calendario = null;
                curvaExecucaoPonto = null;
                stream = null;
            }

            return listaVertices;
        }

        private IList<CurvaExecucaoPonto> LerArquivoXLS(ImportacaoArquivo importArquivo, RegistroExecucaoCurva registroExecucaoCurva)
        {
            string cnnString = String.Format(@"Provider=Microsoft.Jet.OLEDB.4.0;Data Source={0};Extended Properties=""Excel 8.0;HDR=YES;""", string.Format("{0}\\{1}", importArquivo.Diretorio, importArquivo.NomeArquivo));
            return LerArquivoXLS(importArquivo, registroExecucaoCurva, cnnString);
        }

        private IList<CurvaExecucaoPonto> LerArquivoXLSX(ImportacaoArquivo importArquivo, RegistroExecucaoCurva registroExecucaoCurva)
        {
            string cnnString = String.Format(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0};Extended Properties=""Excel 12.0;HDR=YES;""", string.Format("{0}\\{1}", importArquivo.Diretorio, importArquivo.NomeArquivo));
            return LerArquivoXLS(importArquivo, registroExecucaoCurva, cnnString);
        }

        private IList<CurvaExecucaoPonto> LerArquivoXLS(ImportacaoArquivo importArquivo, RegistroExecucaoCurva registroExecucaoCurva, string conexaoArquivo)
        {
            IList<CurvaExecucaoPonto> listaVertices = new List<CurvaExecucaoPonto>();
            CurvaExecucaoPonto curvaExecucaoPonto = null;
            ICalendarioBS calendario = new CalendarioBS();


            string cnnString = String.Format(conexaoArquivo, string.Format("{0}\\{1}", importArquivo.Diretorio, importArquivo.NomeArquivo));
            string isql = "SELECT * FROM [{0}$]";
            System.Data.OleDb.OleDbConnection cnn = new System.Data.OleDb.OleDbConnection(cnnString);
            System.Data.OleDb.OleDbDataAdapter da = new System.Data.OleDb.OleDbDataAdapter(String.Format(isql, importArquivo.NomePlanilha), cnn);
            DataSet ds = new DataSet();
            DataTable dt = new DataTable();

            try
            {
                cnn.Open();
                da.Fill(ds);
                dt = ds.Tables[0];

                CalendarioReguaBS Regua = new CalendarioReguaBS(registroExecucaoCurva.DataHoraExecucaoCurva, registroExecucaoCurva.DataHoraExecucaoCurva.AddDays(Int32.Parse((dt.Rows[dt.Rows.Count - 1]["Prazo"].ToString()))));

                for (int cont = 0; cont < dt.Rows.Count; cont++)
                {
                    if (dt.Rows[cont]["Valor"].ToString() != null && dt.Rows[cont]["Valor"].ToString() != ""
                        && dt.Rows[cont]["Prazo"].ToString() != null && dt.Rows[cont]["Prazo"].ToString() != "")
                    {
                        curvaExecucaoPonto = new CurvaExecucaoPonto();

                        curvaExecucaoPonto.CodigoCurva = registroExecucaoCurva.CodigoCurva;
                        curvaExecucaoPonto.DataHoraExecucaoCurva = registroExecucaoCurva.DataHoraExecucaoCurva;
                        curvaExecucaoPonto.DataInclusaoVigencia = registroExecucaoCurva.DataInclusaoVigencia;
                        curvaExecucaoPonto.IndicadorVertice = SIM;
                        curvaExecucaoPonto.ValorVertice = double.Parse(dt.Rows[cont]["Valor"].ToString());
                        curvaExecucaoPonto.QuantidadeDiasCorridos = Int32.Parse(dt.Rows[cont]["Prazo"].ToString());
                        curvaExecucaoPonto.DataVencimento = registroExecucaoCurva.DataHoraExecucaoCurva.Date.AddDays(Int32.Parse(dt.Rows[cont]["Prazo"].ToString()));
                        curvaExecucaoPonto.QuantidadeDiasUteis = Regua.ObterQuantidadeDiasUteis(curvaExecucaoPonto.DataVencimento.Date.ToString("yyyyMMdd"));

                        listaVertices.Add(curvaExecucaoPonto);
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                cnn.Close();
                cnn.Dispose();
                da.Dispose();
                ds = null;
            }

            return listaVertices;
        }

        public IList<RegistroGradeExecucaoCurva> ObterGradeExecucaoCurva()
        {
            IList<RegistroGradeExecucaoCurva> gradeRegistroExecucaoCurva;

            IExecucaoCurvaDAO execucaoCurvaDAO = null;

            try
            {
                execucaoCurvaDAO = DaoFactory.getExecucaoCurvaDAO();

                gradeRegistroExecucaoCurva = execucaoCurvaDAO.ObterGradeExecucaoCurva();

                return gradeRegistroExecucaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                execucaoCurvaDAO = null;
            }

            return new List<RegistroGradeExecucaoCurva>();
        }

        #endregion
    }
}
